power-assert
Advanced tools
The power-assert npm package is a powerful assertion library for JavaScript. It enhances the standard assertion functionality by providing more descriptive and readable assertion messages, which makes debugging easier. It is particularly useful for testing and development, as it helps developers quickly identify the root cause of test failures.
Basic Assertion
This feature allows you to perform basic assertions. If the assertion fails, power-assert provides a detailed message showing the values of the variables involved in the assertion.
const assert = require('power-assert');
const a = 1;
const b = 2;
assert(a === b);Complex Expression Assertion
Power-assert can handle complex expressions and provide detailed messages that break down the expression into its components, making it easier to understand why an assertion failed.
const assert = require('power-assert');
const user = { name: 'John', age: 30 };
assert(user.age > 20 && user.name === 'Doe');Custom Message
You can provide custom messages for assertions. If the assertion fails, the custom message is displayed along with the detailed breakdown of the assertion.
const assert = require('power-assert');
const x = 5;
const y = 10;
assert(x > y, 'x should be greater than y');Chai is a BDD / TDD assertion library for node and the browser that can be delightfully paired with any JavaScript testing framework. It provides a variety of assertion styles (should, expect, assert) and is highly extensible. Compared to power-assert, Chai offers more flexibility in terms of assertion styles but does not provide the same level of detailed assertion messages.
Jest is a delightful JavaScript Testing Framework with a focus on simplicity. It works out of the box with minimal configuration and provides a rich API for assertions. Jest's built-in assertion library is less detailed in its failure messages compared to power-assert, but it integrates seamlessly with the Jest testing framework and offers a wide range of features for testing.
The assert module provides a simple set of assertion tests that can be used to test invariants. It is part of Node.js core and is very basic compared to power-assert. While it is straightforward and easy to use, it lacks the detailed and descriptive assertion messages that power-assert provides.
Power Assert in JavaScript. Provides descriptive assertion messages through standard assert interface. No API is the best API.
What is power-assert?
assert(any_expression) function)assert(any_expression).require('power-assert') any more. Keep using require('assert'), and power-assert enhances them transparently. See slides: From Library to Tool - power-assert as a General Purpose Assertion Enhancement Toolpower-assert - power = assert. Without code transpilation, power-assert works just as normal assert does.power-assert provides descriptive assertion messages for your tests, like this.
1) Array #indexOf() should return index when the value is present:
AssertionError: # path/to/test/mocha_node.js:10
assert(ary.indexOf(zero) === two)
| | | | |
| | | | 2
| -1 0 false
[1,2,3]
[number] two
=> 2
[number] ary.indexOf(zero)
=> -1
power-assert enhances these assert functions by espower. Produces descriptive message when assertion is failed.
assert(value, [message])assert.ok(value, [message])assert.equal(actual, expected, [message])assert.notEqual(actual, expected, [message])assert.strictEqual(actual, expected, [message])assert.notStrictEqual(actual, expected, [message])assert.deepEqual(actual, expected, [message])assert.notDeepEqual(actual, expected, [message])assert.deepStrictEqual(actual, expected, [message])assert.notDeepStrictEqual(actual, expected, [message])power-assert is fully compatible with assert. So functions below are also available though they are not enhanced (does not produce descriptive message).
assert.fail(actual, expected, message, operator)assert.throws(block, [error], [message])assert.doesNotThrow(block, [message])assert.ifError(value)Since version 1.5.0, power-assert supports "strict mode" as well.
power-assert provides an API for customization.
assert.customize(options)Though power-assert is fully compatible with standard assert interface, all you need to remember is just an assert(any_expression) function in most cases.
The core value of power-assert is absolute simplicity and stability. Especially, power-assert sticks to the simplest form of testing, assert(any_expression).
assert(types[index].name === bob.name)
| || | | | |
| || | | | "bob"
| || | | Person{name:"bob",age:5}
| || | false
| |11 "alice"
| Person{name:"alice",age:3}
["string",98.6,true,false,null,undefined,#Array#,#Object#,NaN,Infinity,/^not/,#Person#]
--- [string] bob.name
+++ [string] types[index].name
@@ -1,3 +1,5 @@
-bob
+alice
TypeError: assert._capt is not a functionassert calls in productionshould/expect code to power-assert?npm install --save-dev power-assert <one of instrumentors>
or
bower install --save-dev power-assert
npm install --save-dev <one of instrumentors>
See CHANGELOG
See HOW TO USE section for more details.
Note: There is an online demo site available.
'use strict';
const assert = require('assert');
describe('Array', function(){
let ary;
beforeEach(() => {
ary = [1,2,3];
});
describe('#indexOf()', () => {
it('should return index when the value is present', () => {
const zero = 0, two = 2;
assert(ary.indexOf(zero) === two);
});
it('should return -1 when the value is not present', () => {
const minusOne = -1, two = 2;
assert.ok(ary.indexOf(two) === minusOne, 'THIS IS AN ASSERTION MESSAGE');
});
});
});
describe('various types', () => {
let types;
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
}
beforeEach(() => {
types = [
'string', 98.6, true, false, null, undefined,
['nested', 'array'],
{object: true},
NaN, Infinity,
/^not/,
new Person('alice', 3)
];
});
it('demo', () => {
const index = types.length -1,
bob = new Person('bob', 5);
assert(types[index].name === bob.name);
});
});
To use power-assert, you need to transform your test code for power-assert output.
Code transform is done by instrumentors below:
If you are using Node.js only, the easiest way is to use intelli-espower-loader. Steps are as follows.
npm install --save-dev mocha power-assert intelli-espower-loader
Put tests into test directory then run. You will see the power-assert output appears.
$ $(npm bin)/mocha --require intelli-espower-loader path/to/test/mocha_node.js
Array
#indexOf()
1) should return index when the value is present
2) should return -1 when the value is not present
various types
3) demo
0 passing (43ms)
3 failing
1) Array #indexOf() should return index when the value is present:
AssertionError: # test/example2.js:13
assert(ary.indexOf(zero) === two)
| | | | |
| | | | 2
| -1 0 false
[1,2,3]
[number] two
=> 2
[number] ary.indexOf(zero)
=> -1
+ expected - actual
-false
+true
at Context.it (test/example2.js:13:13)
2) Array #indexOf() should return -1 when the value is not present:
AssertionError: THIS IS AN ASSERTION MESSAGE # test/example2.js:17
assert.ok(ary.indexOf(two) === minusOne, 'THIS IS AN ASSERTION MESSAGE')
| | | | |
| | | | -1
| 1 2 false
[1,2,3]
[number] minusOne
=> -1
[number] ary.indexOf(two)
=> 1
+ expected - actual
-false
+true
at Context.it (test/example2.js:17:20)
3) various types demo:
AssertionError: # test/example2.js:43
assert(types[index].name === bob.name)
| || | | | |
| || | | | "bob"
| || | | Person{name:"bob",age:5}
| || | false
| |11 "alice"
| Person{name:"alice",age:3}
["string",98.6,true,false,null,undefined,#Array#,#Object#,NaN,Infinity,/^not/,#Person#]
--- [string] bob.name
+++ [string] types[index].name
@@ -1,3 +1,5 @@
-bob
+alice
+ expected - actual
-false
+true
at Context.it (test/example2.js:43:9)
Some seed projects are available to help you start with power-assert.
| module | env | tech stack |
|---|---|---|
| power-assert-node-seed | Node.js | power-assert + intelli-espower-loader |
| power-assert-testem-seed | Browsers(by testem) | power-assert + gulp-espower + testem. |
| power-assert-karma-seed | Browsers(by Karma) | power-assert + espowerify + browserify + Karma. |
There are some ways to use power-assert. (If you want to see running examples, see SEED PROJECTS)
power-assert + Babel + babel-preset-power-assert: The only way to enable power-assert if you are using Babel6+.power-assert + espower-loader or intelli-espower-loader : Simple and recommended (but only works under Node).power-assert + espower-coffee or espower-typescript: Use power-assert with AltJS. Recommended but only works under Node.power-assert + browserify + espowerify: if you are using browserify but not with Babel.power-assert + webpack + webpack-espower-loader: if you are using webpack but not with Babel.power-assert + espower-cli or grunt-espower or gulp-espower : Generate instrumented code so works anywhere.babel-preset-power-assert or babel-plugin-espowerIf you are writing your code with Babel, you can instrument Power Assert feature with Babel and babel-preset-power-assert (or babel-plugin-espower).
see babel-plugin-espower README and babel-preset-power-assert README
espower-loader or intelli-espower-loaderIf you are writing Node.js app/module, you can instrument Power Assert feature without code generation by using espower-loader.
FYI: You may be interested in intelli-espower-loader to go one step further. With intelli-espower-loader, you don't need to create loader file (like enable-power-assert.js). Just define test directory in package.json wow!
espower-typescriptIf you are writing Node.js app/module in TypeScript, you can instrument Power Assert feature without code generation by using espower-typescript.
see espower-typescript README.
espower-coffeeIf you are writing Node.js app/module in CoffeeScript, you can instrument Power Assert feature without code generation by using espower-coffee.
espowerifyIf you are using browserify but not with Babel, you can instrument Power Assert feature via espowerify.
see espowerify README.
webpack-espower-loaderIf you are using webpack but not with Babel, you can instrument Power Assert feature via webpack-espower-loader.
see webpack-espower-loader README.
espower-cliIf you don't want to use grunt, gulp, browserify, and so on, you can use power-assert via bower, with generated code by espower-cli
see espower-cli README.
gulp-espowerOn the browser side and you are not using browserify but bower and gulp, you can use power-assert via bower, with generated code by gulp-espower
see gulp-espower README.
grunt-espowerOn the browser side and you are not using browserify but bower and Grunt, you can use power-assert via bower, with generated code by grunt-espower
see grunt-espower README.
power-assert provides an API for customization.
Through this API, you can customize power-assert by changing some options.
var assert = require('power-assert').customize({
output: {
maxDepth: 2
}
});
options has two top-level keys. assertion and output.
customization options for empower module. See empower API documentation for details. Note that some default values are different from empower's (modifyMessageOnRethrow: true and saveContextOnRethrow: true).
customization options for power-assert-formatter module. See power-assert-formatter API documentation for details.
customizable properties and their default values are as follows.
var assert = require('power-assert').customize({
assertion: {
destructive: false,
modifyMessageOnRethrow: true,
saveContextOnRethrow: true,
patterns: [
'assert(value, [message])',
'assert.ok(value, [message])',
'assert.equal(actual, expected, [message])',
'assert.notEqual(actual, expected, [message])',
'assert.strictEqual(actual, expected, [message])',
'assert.notStrictEqual(actual, expected, [message])',
'assert.deepEqual(actual, expected, [message])',
'assert.notDeepEqual(actual, expected, [message])',
'assert.deepStrictEqual(actual, expected, [message])',
'assert.notDeepStrictEqual(actual, expected, [message])'
]
},
output: {
lineDiffThreshold: 5,
maxDepth: 1,
anonymous: 'Object',
circular: '#@Circular#',
lineSeparator: '\n',
ambiguousEastAsianCharWidth: 2,
widthOf: (Function to calculate width of string. Please see power-assert-formatter's documentation)
stringify: (Function to stringify any target value. Please see power-assert-formatter's documentation)
diff: (Function to create diff string between two strings. Please see power-assert-formatter's documentation)
writerClass: (Constructor Function for output writer class. Please see power-assert-formatter's documentation)
renderers: [
'./built-in/file',
'./built-in/assertion',
'./built-in/diagram',
'./built-in/binary-expression'
]
}
});
power-assert family provides 1 main module, 4 core modules and many more instrumentors.
Main (facade) module is,
| module | description |
|---|---|
| power-assert | Standard assert function on top of empower and power-assert-formatter |
core modules are,
| module | description |
|---|---|
| empower | Power Assert feature enhancer for assert function/object. |
| power-assert-formatter | Power Assert output formatter. |
| espower | Power Assert feature instrumentor core based on the ECMAScript AST defined in The ESTree Spec (formerly known as Mozilla SpiderMonkey Parser API). |
| espower-source | Power Assert instrumentor from source to source, with source-map. (Thin wrapper of espower). |
and instrumentors are,
| module | description |
|---|---|
| espower-loader | Node module loader to apply espower on the fly. |
| intelli-espower-loader | configure espower-loader with ease. |
| babel-preset-power-assert | Babel preset to instrument power-assert feature into target files. |
| babel-plugin-espower | Babel plugin to instrument power-assert feature into target files. |
| espowerify | Browserify transform to apply espower to target files. |
| webpack-espower-loader | Power Assert instrumentor module for webpack. |
| espower-cli | Command line tool for power-assert. |
| grunt-espower | Grunt task to apply espower to target files. |
| gulp-espower | Gulp plugin to apply espower to target files. |
| karma-espower-preprocessor | karma-preprocessor for power-assert. |
| espower-coffee | power-assert instrumentor for CoffeeScript. |
| espower-typescript | power-assert instrumentor for TypeScript. |
| espower-traceur | power-assert instrumentor for ES6 using Traceur Compiler. |
| espower-babel | [DEPRECATED] power-assert instrumentor for ES6 using Babel. |
power-assert provides standard assert compatible function with Power Assert feature.
(Best fit with Mocha. If you use assert-like objects provided by various testing frameworks such as QUnit or nodeunit. Please use empower and power-assert-formatter modules directly).
Internally, power-assert uses empower module to enhance power assert feature into the standard assert module, to run with the power assert feature added code by espower module, and prettify output using power-assert-formatter.
See power-assert-demo project for power-assert Demo running with mocha.
For the Transpiler side, we support Node under maintenance. In other words, we stop supporting old Node version when their maintenance ends.
For the Runtime side, we support Node under maintenance and "modern enough" browsers such as Chrome, Firefox, Safari, Edge etc.
Any other environments are not supported officially (means that we do not test against them on CI service). power-assert is known to work with old browsers, and trying to keep them working though.
Licensed under the MIT license.
var q = require('qunitjs');
(function () {
var empower = require('empower'),
formatter = require('power-assert-formatter'),
qunitTap = require("qunit-tap");
empower(q.assert, formatter(), {destructive: true});
qunitTap(q, require('util').puts, {showSourceOnFailure: false});
q.config.autorun = false;
})();
q.test('spike', function (assert) {
assert.ok(true);
var hoge = 'foo';
var fuga = 'bar';
assert.ok(hoge === fuga, 'comment');
var piyo = 3;
assert.ok(fuga === piyo);
var longString = 'very very loooooooooooooooooooooooooooooooooooooooooooooooooooong message';
var anotherLongString = 'yet another loooooooooooooooooooooooooooooooooooooooooooooooooooong message';
assert.ok(longString === anotherLongString);
assert.ok(4 === piyo);
assert.ok(4 !== 4);
var falsyStr = '';
assert.ok(falsyStr);
var falsyNum = 0;
assert.ok(falsyNum);
var ary1 = ['foo', 'bar'];
var ary2 = ['aaa', 'bbb', 'ccc'];
assert.ok(ary1.length === ary2.length);
assert.deepEqual(ary1, ary2);
var actual = 16;
assert.ok(5 < actual && actual < 13);
actual = 4;
assert.ok(5 < actual && actual < 13);
actual = 10;
assert.ok(actual < 5 || 13 < actual);
var propName = 'bar',
foo = {
bar: {
baz: false
}
};
assert.ok(foo.bar.baz);
assert.ok(foo['bar'].baz);
assert.ok(foo[propName]['baz']);
var truth = true;
assert.ok(!truth);
var func = function () { return false; };
assert.ok(func());
var obj = {
age: function () {
return 0;
}
};
assert.ok(obj.age());
var isFalsy = function (arg) {
return !(arg);
};
var positiveInt = 50;
assert.ok(isFalsy(positiveInt));
var sum = function () {
var result = 0;
for (var i = 0; i < arguments.length; i += 1) {
result += arguments[i];
}
return result;
};
var one = 1, two = 2, three = 3, seven = 7, ten = 10;
assert.ok(sum(one, two, three) === seven);
assert.ok(sum(sum(one, two), three) === sum(sum(two, three), seven));
assert.ok((three * (seven * ten)) === three);
var math = {
calc: {
sum: function () {
var result = 0;
for (var i = 0; i < arguments.length; i += 1) {
result += arguments[i];
}
return result;
}
}
};
assert.ok(math.calc.sum(one, two, three) === seven);
});
q.load();
espower code above then running under Node.js# module: undefined
# test: spike
ok 1 - okay
not ok 2 - comment # path/to/examples/qunit_node.js:17
#
# assert.ok(hoge === fuga, 'comment')
# | | |
# | | "bar"
# | false
# "foo"
#
# --- [string] fuga
# +++ [string] hoge
# @@ -1,3 +1,3 @@
# -bar
# +foo
#
# , test: spike
not ok 3 - # path/to/examples/qunit_node.js:20
#
# assert.ok(fuga === piyo)
# | | |
# | | 3
# | false
# "bar"
#
# [number] piyo
# => 3
# [string] fuga
# => "bar"
# , test: spike
not ok 4 - # path/to/examples/qunit_node.js:24
#
# assert.ok(longString === anotherLongString)
# | | |
# | | "yet another loooooooooooooooooooooooooooooooooooooooooooooooooooong message"
# | false
# "very very loooooooooooooooooooooooooooooooooooooooooooooooooooong message"
#
# --- [string] anotherLongString
# +++ [string] longString
# @@ -1,15 +1,13 @@
# -yet anoth
# +very v
# er
# +y
# loo
#
# , test: spike
not ok 5 - # path/to/examples/qunit_node.js:26
#
# assert.ok(4 === piyo)
# | |
# | 3
# false
#
# [number] piyo
# => 3
# [number] 4
# => 4
# , test: spike
not ok 6 - # path/to/examples/qunit_node.js:28
#
# assert.ok(4 !== 4)
# |
# false
# , test: spike
not ok 7 - # path/to/examples/qunit_node.js:31
#
# assert.ok(falsyStr)
# |
# ""
# , test: spike
not ok 8 - # path/to/examples/qunit_node.js:34
#
# assert.ok(falsyNum)
# |
# 0
# , test: spike
not ok 9 - # path/to/examples/qunit_node.js:38
#
# assert.ok(ary1.length === ary2.length)
# | | | | |
# | | | | 3
# | | | ["aaa","bbb","ccc"]
# | 2 false
# ["foo","bar"]
#
# [number] ary2.length
# => 3
# [number] ary1.length
# => 2
# , test: spike
not ok 10 - # path/to/examples/qunit_node.js:39
#
# assert.deepEqual(ary1, ary2)
# | |
# | ["aaa","bbb","ccc"]
# ["foo","bar"]
# , expected: [
# "aaa",
# "bbb",
# "ccc"
# ], got: [
# "foo",
# "bar"
# ], test: spike
not ok 11 - # path/to/examples/qunit_node.js:42
#
# assert.ok(5 < actual && actual < 13)
# | | | | |
# | | | 16 false
# | 16 false
# true
# , test: spike
not ok 12 - # path/to/examples/qunit_node.js:45
#
# assert.ok(5 < actual && actual < 13)
# | | |
# | 4 false
# false
# , test: spike
not ok 13 - # path/to/examples/qunit_node.js:48
#
# assert.ok(actual < 5 || 13 < actual)
# | | | | |
# | | | | 10
# | | false false
# 10 false
# , test: spike
not ok 14 - # path/to/examples/qunit_node.js:58
#
# assert.ok(foo.bar.baz)
# | | |
# | | false
# | Object{baz:false}
# Object{bar:#Object#}
# , test: spike
not ok 15 - # path/to/examples/qunit_node.js:59
#
# assert.ok(foo['bar'].baz)
# | | |
# | | false
# | Object{baz:false}
# Object{bar:#Object#}
# , test: spike
not ok 16 - # path/to/examples/qunit_node.js:60
#
# assert.ok(foo[propName]['baz'])
# | || |
# | |"bar" false
# | Object{baz:false}
# Object{bar:#Object#}
# , test: spike
not ok 17 - # path/to/examples/qunit_node.js:64
#
# assert.ok(!truth)
# ||
# |true
# false
# , test: spike
not ok 18 - # path/to/examples/qunit_node.js:68
#
# assert.ok(func())
# |
# false
# , test: spike
not ok 19 - # path/to/examples/qunit_node.js:76
#
# assert.ok(obj.age())
# | |
# | 0
# Object{age:#function#}
# , test: spike
not ok 20 - # path/to/examples/qunit_node.js:83
#
# assert.ok(isFalsy(positiveInt))
# | |
# false 50
# , test: spike
not ok 21 - # path/to/examples/qunit_node.js:94
#
# assert.ok(sum(one, two, three) === seven)
# | | | | | |
# | | | | | 7
# 6 1 2 3 false
#
# [number] seven
# => 7
# [number] sum(one, two, three)
# => 6
# , test: spike
not ok 22 - # path/to/examples/qunit_node.js:95
#
# assert.ok(sum(sum(one, two), three) === sum(sum(two, three), seven))
# | | | | | | | | | | |
# | | | | | | 12 5 2 3 7
# 6 3 1 2 3 false
#
# [number] sum(sum(two, three), seven)
# => 12
# [number] sum(sum(one, two), three)
# => 6
# , test: spike
not ok 23 - # path/to/examples/qunit_node.js:96
#
# assert.ok(three * (seven * ten) === three)
# | | | | | | |
# | | | | | | 3
# | | | | 10 false
# | | 7 70
# 3 210
#
# [number] three
# => 3
# [number] three * (seven * ten)
# => 210
# , test: spike
not ok 24 - # path/to/examples/qunit_node.js:110
#
# assert.ok(math.calc.sum(one, two, three) === seven)
# | | | | | | | |
# | | | | | | | 7
# | | 6 1 2 3 false
# | Object{sum:#function#}
# Object{calc:#Object#}
#
# [number] seven
# => 7
# [number] math.calc.sum(one, two, three)
# => 6
# , test: spike
1..24
Have fun!
FAQs
Power Assert in JavaScript
We found that power-assert demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
An advanced npm supply chain attack is leveraging Ethereum smart contracts for decentralized, persistent malware control, evading traditional defenses.
Security News
Research
Attackers are impersonating Sindre Sorhus on npm with a fake 'chalk-node' package containing a malicious backdoor to compromise developers' projects.
Security News
The npm package for the LottieFiles Player web component was hit with a supply chain attack after a software engineer's npmjs credentials were compromised.